home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / Source / Telnet 2.6.1d1 4⁄26⁄94 Folder / source / vr / vdevice.c next >
Text File  |  1994-02-20  |  6KB  |  211 lines
  1. #ifndef __ALLNU__
  2. #define __ALLNU__
  3.  
  4. #ifdef MPW
  5. #pragma segment ICR
  6. #endif
  7.  
  8. #include "TelnetHeader.h"
  9.  
  10. #include <Palettes.h>
  11. #endif
  12.  
  13. #include "vdevice.h"
  14.  
  15. extern TelInfoRec *TelInfo;
  16. extern SysEnvRec theWorld;                        /* System Environment record */
  17.  
  18. /*************************************************************************/
  19. /* Virtual drawing device code.
  20. *
  21. *  
  22. *  InitVDevice()        fill in the fields of a vdevice and allocate the gdevice.
  23. *  SetVDevice()         set the device and port for off-screen drawing.
  24. *                       this only pushes the old values 1-deep, no stack.
  25. *  UnsetVDevice()       set the device and port back to what they were.
  26. *  TrashVDevice()       dispose and close all fields in the vdevice.
  27. *  ColorVDevice()       set the color palette for the 8-bit vdevice.
  28. */
  29. GDHandle v_savegd;        /* the saved gdevice */
  30. CGrafPtr v_saveport;    /* the saved port from SetPort */
  31.  
  32. /*************************************************************************/
  33. /* InitVDevice
  34. *  allocate an off-screen pixmap and off-screen gdevice which can be drawn
  35. *  in without the palette manager affecting the colors.  If we use MakeITable
  36. *  ourselves and don't install the gdevice into the gdevice list or make it
  37. *  active, then the palette manager ignores it, but QuickDraw works on it.
  38. *
  39. *  set vdev->bounds to the size you need before calling.
  40. *  allocate vdev->bp enough space to hold one byte per pixel of a rectangle that
  41. *  size.
  42. *
  43. *  returns 0 if ok,
  44. *  returns -1 or other negative on other errors.
  45. */
  46. int InitVDevice
  47.   (
  48.     VDevicePtr vdev
  49.   )
  50. {
  51.     GDHandle thegd;
  52.     PixMapHandle pm;
  53.     Rect tr;
  54.     CTabHandle ct;
  55.     int width;
  56.  
  57.     GetPort((GrafPtr *) &v_saveport);
  58.     v_savegd = GetGDevice();            /* get old values */
  59.     
  60.     tr = vdev->bounds;                    /* get size of device to create */
  61.     if (tr.right - tr.left < 1 ||
  62.         tr.bottom - tr.top < 1)
  63.         return(-1);                        /* check for simple mistake */
  64.         
  65.     width = tr.right - tr.left;
  66.     
  67.     if (!vdev->bp)
  68.         return(-2);                        /* another simple mistake */
  69. /*
  70. *  Allocate the off-screen PixMap for drawing a duplicate copy.  The off-screen
  71. *  gdevice, CPort and PixMap form a virtual drawing space with its own color map.
  72. *  For this program, we have chosen to make this virtual space an 8-bit drawing
  73. *  device.  When drawing, use SetVDevice and UnsetVDevice to turn on and off.
  74. * 
  75. */
  76.     thegd = vdev->vgd = NewGDevice( 0, -1 );
  77.     
  78.     pm = (PixMapHandle) NewHandle(sizeof(PixMap));
  79.  
  80.     if (width & 1)    {                    /* must be even */
  81.         --tr.right;
  82.         --width;
  83.     }
  84.     (*pm)->baseAddr = (Ptr) vdev->bp;    /* BYU LSC - get memory to use */
  85.     (*pm)->rowBytes = width | 0x8000;    /* setting high flag bit */
  86.     (*pm)->bounds = tr;
  87.     (*pm)->pixelSize = 8;                /* source is 8-bits */
  88.     (*pm)->pixelType = 0;                /* chunky */
  89.     (*pm)->cmpCount = 1;                /* chunky */
  90.     (*pm)->cmpSize = 8;                    /* chunky */
  91.     (*pm)->planeBytes = 0;                /* chunky */
  92.     (*pm)->pmVersion = 0;                /* chunky */
  93.     (*pm)->packSize = 0;                /* chunky */
  94.     (*pm)->packType = 0;                /* chunky */
  95.     ct = (CTabHandle)NewHandle(sizeof(ColorTable));
  96.     (*pm)->pmTable = ct;
  97.     (*ct)->ctSeed = GetCTSeed();
  98.     (*ct)->ctFlags = 0x8000;
  99.     (*ct)->ctSize = 1;                    /* 1-length color table (empty) */
  100.     
  101.     (*thegd)->gdResPref = 3;            /* inverse table size preferred */
  102.     (*thegd)->gdRect = tr;                /* device size boundary */
  103.  
  104.     (*thegd)->gdPMap = pm;                /* copy pixmap handle */
  105.     
  106.     SetDeviceAttribute(thegd,noDriver,true);
  107.     SetDeviceAttribute(thegd,gdDevType,true);
  108.     
  109.     SetGDevice(thegd);
  110.                         /* CPort inherits from the gdevice, including pixmap */
  111.     if (theWorld.hasColorQD)                        /* BYU */
  112.         OpenCPort(&vdev->vport);        /* BYU - initialize the port struct */
  113.     SetPort((GrafPtr) &vdev->vport);
  114.     ClipRect(&tr);                        /* set clip region */
  115.  
  116. /*
  117. *  Erase the image region in the virtual device. 
  118. */
  119.     EraseRect(&tr);
  120.  
  121. /*
  122. *  Restore the environment.
  123. */
  124.     SetGDevice(v_savegd);
  125.     SetPort((GrafPtr) v_saveport);
  126.     
  127.     return(0);
  128. }
  129.  
  130. /*******************************************************************************/
  131. /* SetVDevice
  132. *  Set the gdevice and port to our off-screen space.
  133. *  Save the old values for unset.
  134. */
  135. SetVDevice(VDevicePtr vdev)
  136. {
  137.  
  138.     GetPort((GrafPtr *) &v_saveport);
  139.     v_savegd = GetGDevice();
  140.     if (!vdev->vgd)
  141.         return(-1);
  142.     SetGDevice(vdev->vgd);
  143.     SetPort((GrafPtr) &vdev->vport);
  144.     
  145.     return(0);
  146. }
  147.  
  148. /*******************************************************************************/
  149. /* UnsetVDevice
  150. *  Set the vdevice back to the saved values.
  151. */
  152. UnsetVDevice(void)
  153. {
  154.     SetGDevice(v_savegd);
  155.     SetPort((GrafPtr) v_saveport);
  156. }
  157.  
  158. /*******************************************************************************/
  159. /* TrashVDevice
  160. *  Get rid of the devices that we created with InitVDevice.
  161. *
  162. *  Remember to free up the vdev->bp after the gdevice is gone.
  163. */
  164. void TrashVDevice
  165.   (
  166.     VDevicePtr vdev
  167.   )
  168. {
  169.     
  170.     (*((*(vdev->vgd))->gdPMap))->baseAddr = NULL;    /* drop old value, bp has a copy */
  171.         
  172.     if (theWorld.hasColorQD)                    /* BYU */
  173.         CloseCPort(&vdev->vport);    /* BYU - lose the cport, disposes the pixmap */
  174.     (*(vdev->vgd))->gdPMap = NULL;    /* destroy second copy of the pixmaphandle */
  175.     
  176.     DisposGDevice(vdev->vgd);        /* disposes current gdevice and pixmap */
  177.     vdev->vgd = NULL;
  178.  
  179. }
  180.  
  181. /*******************************************************************************/
  182. /*  ColorVDevice
  183. *   input:  vdev and 
  184. *        palette handle.
  185. *   
  186. *   Use palette2ctab to install the color table into the off-screen gdevice and
  187. *   make the inverse color table for it.  Also install the palette into the current
  188. *   window.
  189. */
  190. void ColorVDevice
  191.   (
  192.     VDevicePtr vdev,
  193.     PaletteHandle pal
  194.   )
  195. {
  196.     CTabHandle ct;
  197.  
  198.     ct = (*(*(vdev->vgd))->gdPMap)->pmTable;        /* handle from vdevice */
  199.     if (!ct)
  200.         return;
  201.     
  202.     Palette2CTab( pal, ct );
  203.  
  204.     (*ct)->ctSeed = GetCTSeed();                    /* give it a unique seed */
  205.     (*ct)->ctFlags = 0x8000;
  206.     
  207.     MakeITable( ct, (*(vdev->vgd))->gdITable, 3 );    /* 3-bit inverse table  */
  208.  
  209. }
  210.  
  211.